package com.example.robertluozizhao.framecollectdemo.util;

import android.text.TextUtils;
import android.util.Log;
import java.io.InputStream;
import java.net.Socket;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;


/**
 * 日期工具类
 *
 * @author christinRuan
 * @version V1.0 <描述当前版本功能>
 * @FileName com.example.picturestoragedemo.utils.DateUtils.java
 * @date 2016-3-31 上午10:15:10
 */
public class DateUtil {
    public final static String FORMAT_YYYY_MM_DD = "yyyy-MM-dd";
    public final static String FORMAT_YYYY_MM = "yyyy-MM";
    public final static String FORMAT_YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
    public final static String FORMATYYYYMMDDHHMMSS = "yyyyMMddHHmmss";
    public final static String FORMAT_HH_MM_SS = "HH:mm:ss";
    public final static String FORMAT_MM_SS = "mm:ss";
    public final static String FORMAT_HH_MM = "HH:mm";
    public final static String FORMAT_MM_DD_HH_MM_SS = "MM-dd HH:mm:ss";
    public final static String FORMAT_YYMMDD_HHMMSS = "yyyyMMdd.HHmmss";
    public final static String FORMAT_YYYY_MM_DD_HH_MM = "yyyy-MM-dd HH:mm";
    public final static String FORMAT_YYYY_MM_DD_HH_MM_SS_ = "yyyy_MM_dd_HH_mm_ss";
    public final static String FORMAT_YYYYMMDD = "yyyyMMdd";


    public static final int DEFAULT_PORT = 37;
    public static final String DEFAULT_HOST = "time-nw.nist.gov";

    /**
     * 当前时间，Date类型
     *
     * @return
     * @author christineRuan
     * @date 2013-12-15 上午11:59:34
     * @returnType Date
     */
    public static Date getCurrDate() {
        return new Date();
    }

    /**
     * 时间对象按指定格式转换为字符串时间
     *
     * @param date    时间对象
     * @param pattern 时间格式
     * @return
     * @author christineRuan
     * @date 2013-12-5 上午9:45:34
     * @returnType String
     */
    public static String formatDate(Date date, String pattern) {
        SimpleDateFormat format = new SimpleDateFormat(pattern);
        try {
            return format.format(date);
        } catch (Exception e) {
            Log.e(DateUtil.class.getName(), e.toString());
            return "";
        }
    }

 /*   public static String formaDate(String timeLong, String pattern) {
        if (TextUtils.isEmpty(timeLong)) {
            return "";
        }
        long time = Math.isNum(timeLong) ? Long.parseLong(timeLong) : 0;
        if (0 == time) {
            return "";
        }
        Date date = new Date(time);
        return formatDate(date, pattern);

    }
*/

    /**
     * 获取yyyy-MM-dd格式的当前时间
     *
     * @author christinRuan
     * @date 2016/6/12  17:14
     * @returnType 返回短时间字符串格式yyyy-MM-dd
     */
    public static String getCurrentDateYmd() {
        return formatCurrentDateByUser(FORMAT_YYYY_MM_DD);
    }

    /**
     * 获取yyyy-MM格式的当前时间
     *
     * @author christinRuan
     * @date 2016/6/12  17:14
     * @returnType 返回短时间字符串格式yyyy-MM-dd
     */
    public static String getCurrentDateYm() {
        return formatCurrentDateByUser(FORMAT_YYYY_MM);
    }

    /**
     * 获取yyyyMMdd格式的当前时间
     *
     * @author christinRuan
     * @date 2016/6/12  17:14
     * @returnType 返回短时间字符串格式yyyy-MM-dd
     */
    public static String getCurrentDateYMD() {
        return formatCurrentDateByUser(FORMAT_YYYYMMDD);
    }

    public static String getCurDateYMDHMS() {
        return formatCurrentDateByUser(FORMAT_YYYY_MM_DD_HH_MM_SS);
    }

    /**
     * 获取自定义时间格式的现在时间
     *
     * @author christinRuan
     * @date 2016/6/12  17:15
     * @returnType
     */
    public static String formatCurrentDateByUser(String timeFormat) {
        return formatDate(getCurrDate(), timeFormat);
    }

    /**
     * 获取当前时间所需格式
     *
     * @param format 所需时间格式
     * @return 返回所需格式的当前时间
     * @author christineRuan
     * @date 2013-12-5 上午9:30:55
     * @returnType
     */
    public static String getCurrentDateString(String format) {
        return formatDate(getCurrDate(), format);
    }


    /**
     * 获取当前时间 2016-6-13 10:49:50:880
     *
     * @author christinRuan
     * @date 2016/6/13  10:55
     * @returnType
     */
    public static final String getCurrentTimeString() {
        Calendar calendar = Calendar.getInstance();
        String created = calendar.get(Calendar.YEAR) + "-"
                + (calendar.get(Calendar.MONTH) + 1) + "-"
                + calendar.get(Calendar.DAY_OF_MONTH) + " "
                + calendar.get(Calendar.HOUR_OF_DAY) + ":"
                + calendar.get(Calendar.MINUTE) + ":"
                + calendar.get(Calendar.SECOND) + ":"
                + calendar.get(Calendar.MILLISECOND);
        return created;
    }


    /**
     * @param strTime    要转换的String类型的时间
     * @param formatType 要转换的时间格式类似 yyyy-MM-dd HH:mm:ss
     *                   strTime的时间格式和formatType的时间格式必须相同
     * @author fcz
     */
    public static long stringToLong(String strTime, String formatType) {
        if (TextUtils.isEmpty(strTime)) {
            return 0;
        }
        Date date = stringToDate(strTime, formatType);
        if (date == null) {
            return 0;
        } else {
            long currentTime = dateToLong(date); // date类型转成long类型
            return currentTime;
        }
    }


    /**
     * Long转成指定格式的String
     *
     * @param currentTime 要转换的long类型的时间
     * @author fcz
     */
    public static String longToString(long currentTime) {
        return longToString(currentTime, FORMAT_YYYY_MM_DD_HH_MM_SS);
    }

    /**
     * Long转成指定格式的String
     *
     * @param formatType  格式为类似yyyy-MM-dd HH:mm:ss
     * @param currentTime 要转换的long类型的时间
     * @author fcz
     */
    public static String longToString(long currentTime, String formatType) {
        if (currentTime == 0) {
            return "";
        }
        Date date = longToDate(currentTime, formatType); // long类型转成Date类型
        String strTime = dateToString(date, formatType); // date类型转成String
        return strTime;
    }

    /**
     * @param currentTime 要转换的long类型的时间
     * @param formatType  要转换的时间格式类似 yyyy-MM-dd HH:mm:ss
     * @author fcz
     */
    public static Date longToDate(long currentTime, String formatType) {
        Date dateOld = new Date(currentTime); // 根据long类型的毫秒数生命一个date类型的时间
        String sDateTime = dateToString(dateOld, formatType); // 把date类型的时间转换为string
        Date date = stringToDate(sDateTime, formatType); // 把String类型转换为Date类型
        return date;
    }

    /**
     * Date转成指定格式的String
     *
     * @param formatType 格式为类似yyyy-MM-dd HH:mm:ss
     * @param data       Date类型的时间
     * @author fcz
     */
    public static String dateToString(Date data, String formatType) {
        return new SimpleDateFormat(formatType).format(data);
    }

    /**
     * String 转Date
     *
     * @param strTime    要转换的string类型的时间
     * @param formatType 要转换的格式类似 yyyy-MM-dd HH:mm:ss
     *                   注意：strTime的时间格式必须要与formatType的时间格式相同，不一致返回null
     * @author fcz
     */
    public static Date stringToDate(String strTime, String formatType) {
        SimpleDateFormat formatter = new SimpleDateFormat(formatType);
        formatter.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
        Date date = null;
        try {
            date = formatter.parse(strTime);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * Date 转成long
     *
     * @param
     * @author fcz
     */
    public static long dateToLong(Date date) {
        return date.getTime();
    }

    /**
     * 根据秒数算时间格式
     *
     * @param elapsedSeconds 秒数
     * @param format         时间格式  目前只支持HH:mm:ss和mm:ss两种格式
     * @return 秒数根据格式所换算出来的值
     * @author christinRuan
     * @date 2016/7/20  11:09
     * @returnType string
     */
    public static String formatElapsedTime(long elapsedSeconds, String format) {
        long hours = 0;
        long minutes = 0;
        long seconds = 0;
        if (elapsedSeconds >= 3600) {
            hours = elapsedSeconds / 3600;
            elapsedSeconds -= hours * 3600;
        }
        if (elapsedSeconds >= 60) {
            minutes = elapsedSeconds / 60;
            elapsedSeconds -= minutes * 60;
        }
        seconds = elapsedSeconds;
        if (FORMAT_HH_MM_SS.equals(format)) {
            return String.format("%02d:%02d:%02d", hours, minutes, seconds);
        } else if (FORMAT_MM_SS.equals(format)) {
            return String.format("%02d:%02d", minutes, seconds);
        }
        return "";
    }

    /**
     * 根据时分转换为Date类型
     *
     * @param
     * @return
     * @author YangLinWei
     * @date 2016/8/19  9:20
     * @returnType
     */
    public static Date parseDate(String hh_MM) {
        SimpleDateFormat format = new SimpleDateFormat(FORMAT_HH_MM);
        try {
            return format.parse(hh_MM);
        } catch (ParseException e) {
            Log.e(DateUtil.class.getName(), e.toString());
        }
        return null;
    }

    /**
     * 根据年月日时分获取Date类型
     *
     * @param
     * @return
     * @author YangLinWei
     * @date 2017/4/7  11:05
     * @returnType
     */
    public static Date parseDateYMDHM(String yyyyMMDDHHmm) {
        SimpleDateFormat format = new SimpleDateFormat(FORMAT_YYYY_MM_DD_HH_MM);
        try {
            Date date = format.parse(yyyyMMDDHHmm);
            date.setYear(date.getYear() + 1900);
            date.setMonth(date.getMonth() + 1);
            date.setDate(date.getDate());
            date.setHours(date.getHours());
            date.setMinutes(date.getMinutes());
            return date;
        } catch (Exception e) {
            Log.e("xxx", e.toString());
        }
        return null;
    }

    /**
     * 根据日期的字符串，获取日期中指定格式的字符串
     *
     * @param time 日期的字符串
     * @return
     * @author YangLinWei
     * @date 2016/8/22  9:22
     * @returnType
     */
    public static String getExecuteTime(String time) {
        try {
            Date date = new Date(time);
            return String.format("%02d:%02d", date.getHours(), date.getMinutes());
        } catch (Exception e) {
            Log.e(DateUtil.class.getName(), e.toString());
        }
        return null;
    }

    /**
     * 秒转分
     *
     * @param
     * @return
     * @author YangLinWei
     * @date 2016/8/22  10:16
     * @returnType
     */
    public static String seconds2Min(int seconds) {
        try {
            int hours = seconds / 60 / 60;
            int minutes = (seconds / 60) + (seconds % 60) - (hours * 60);
            return String.format("%d小时 %02d分", hours, minutes);
        } catch (Exception e) {
            Log.e(DateUtil.class.getName(), e.toString());
        }
        return "";

    }

    /**
     * 获取系统当前系统时间
     *
     * @return 时间
     * @author ljk
     * @date 2016/7/20  11:09
     * @returnType string
     */
    public static String currentTime() {
        Date date = new Date();//创建一个时间对象，获取到当前的时间
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置时间显示格式
        String str = sdf.format(date);//将当前时间格式化为需要的类型
        return str;
    }


    /**
     * @desc 获取系统当前系统时间 yyyy-MM-dd HH:mm
     * @author luo_zi_zhao
     * @date create at 2019/1/8 14:47
     */
    public static String currentTimeFormatHHmm() {
        Date date = new Date();//创建一个时间对象，获取到当前的时间
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");//设置时间显示格式
        String str = sdf.format(date);//将当前时间格式化为需要的类型
        return str;
    }

    /**
     * 获取系统当前系统时间
     *
     * @return 时间
     * @author ljk
     * @date 2016/7/20  11:09
     * @returnType string
     */
    public static String currentTimeHm() {
        Date date = new Date();//创建一个时间对象，获取到当前的时间
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");//设置时间显示格式
        String str = sdf.format(date);//将当前时间格式化为需要的类型
        return str;
    }

    /**
     * 获取系统当前系统时间
     *
     * @return 时间
     * @author ljk
     * @date 2016/7/20  11:09
     * @returnType string
     */
    public static String currentTimeYmd() {
        Date date = new Date();//创建一个时间对象，获取到当前的时间
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");//设置时间显示格式
        String str = sdf.format(date);//将当前时间格式化为需要的类型
        return str;
    }

    /**
     * 根据时间戳获取系统当前系统时间
     *
     * @return 时间
     * @author ljk
     * @date 2016/7/20  11:09
     * @returnType string
     */
    public static String currentTime(Long timeStamp) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String str = format.format(timeStamp);
        return str;
    }

    /**
     * 获取网络时间
     *
     * @param sync 是否同步获取网络时间
     * @return 返回时间戳
     * @author christinRuan
     * @date 2016/8/1  1:22
     * @returnType long
     */
    public static long currentTimeMillis(Boolean sync) {
        if (sync != null && sync.booleanValue() != true)
            return System.currentTimeMillis();
        try {
            return syncCurrentTime();
        } catch (Exception e) {
            Log.e(DateUtil.class.getName(), e.toString());
            return System.currentTimeMillis();
        }
    }

    public static long syncCurrentTime() throws Exception {
        long differenceBetweenEpochs = 2208988800L;
        InputStream raw = null;
        Socket theSocket = null;
        try {
            theSocket = new Socket(DEFAULT_HOST, DEFAULT_PORT);
            raw = theSocket.getInputStream();

            long secondsSince1900 = 0;
            for (int i = 0; i < 4; i++) {
                secondsSince1900 = (secondsSince1900 << 8) | raw.read();
            }
            if (raw != null)
                raw.close();
            long secondsSince1970 = secondsSince1900 - differenceBetweenEpochs;
            long msSince1970 = secondsSince1970 * 1000;
            return msSince1970;
        } catch (Exception e) {
            Log.e(DateUtil.class.getName(), e.toString());
            throw new Exception(e);
        } finally {
            if (theSocket != null) {
                theSocket.close();
            }
        }
    }


    /**
     * 是否在区间里<br/>
     * 判断某一时间是否在某一时间区间里<br/>
     *
     * @param st       开始时间  et结束时间  格式为"82800000"==>23:00
     * @param currTime 需判断的时间
     * @return true:在区间里;false:不在区间里
     * @author christinRuan
     * @date 2016/11/8  11:15
     * @returnType boolean
     */
    public static boolean isInterval(long st, long et, long currTime) {
        if (st > et) {
            //A1:当前时间在开始时间和凌晨转钟的区间里  23:00-02:00    c 23:30:00:000
            //A2:当前时间在开始时间和结束时间区间里      07:00-02:00    c 08:00:00:000
            if (currTime >= st && currTime <= 86399099) {
                return true;
            }
            //B1:当前时间在转钟和结束区间里  23:00-02:00    c 1:30:00:000
            if (currTime < st && 0 <= currTime && currTime <= et) {
                return true;
            }
            return false;
        } else {
            if (st <= currTime && currTime <= et) {
                return true;
            }
            return false;
        }

    }

    /**
     * 获取当前时间的时分秒毫秒
     *
     * @return 返回当前时间的时分秒毫秒
     * @author christinRuan
     * @date 2016/6/13  10:55
     * @returnType long
     */
    public static final long getCurrHMSM() {
        Calendar calendar = Calendar.getInstance();
        int h = calendar.get(Calendar.HOUR_OF_DAY);
        int m = calendar.get(Calendar.MINUTE);
        int s = calendar.get(Calendar.SECOND);
        int mi = calendar.get(Calendar.MILLISECOND);

        System.out.println(String.format("当前HH:MM:SS:MMM【%02d:%02d:%02d:%03d】", h, m, s, mi));
        long hmsmi = h * 60 * 60 * 1000 + m * 60 * 1000 + s * 1000 + mi;
        System.out.println(String.format("当前时分秒毫秒的时间戳【%s】", hmsmi));
        return hmsmi;
    }

    /**
     * 获取时间的相差数
     *
     * @param begintime 开始时间 yyyy-MM-dd HH:mm:ss
     * @param endtime   结束时间 yyyy-MM-dd HH:mm:ss
     * @param type      类型常量 0 - 秒 1 - 分钟 2 - 小时 3 - 天
     * @return 相差的秒，分钟，小时，天
     * @author YangLinWei
     * @date 2016/12/27  18:41
     * @returnType int
     */
    public static int getDifferenceTime(String begintime, String endtime, int type) {
        try {
            SimpleDateFormat inputFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.getDefault());
            long startT = inputFormat.parse(begintime).getTime();
            long endT = inputFormat.parse(endtime).getTime();

            long secd = (endT - startT) / (1000); // 共计秒数
            int mint = (int) secd / 60; // 共计分钟数
            int hor = (int) secd / 3600; // 共计小时数
            int day = (int) hor / 24; // 共计天数

            switch (type) {
                case 0:
                    return (int) secd;
                case 1:
                    return mint;
                case 2:
                    return hor;
                case 3:
                    return day;
                default:
                    return 0;
            }
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return -1;
    }

    /**
     * 获取当年
     *
     * @return
     */
    public static int getCurrentYear() {
        return Calendar.getInstance().get(Calendar.YEAR);
    }

    /**
     * 获取当月
     *
     * @param
     * @return
     * @author YangLinWei
     * @date 2017/2/10  11:32
     * @returnType
     */
    public static int getCurrentMonth() {
        return Calendar.getInstance().get(Calendar.MONTH);
    }

    /**
     * 获取每周的周几
     *
     * @param
     * @return
     * @author YangLinWei
     * @date 2017/2/10  11:32
     * @returnType
     */
    public static int getCurrentDay() {
        return Calendar.getInstance().get(Calendar.DAY_OF_WEEK);
    }

    /**
     * 获取当时
     *
     * @param
     * @return
     * @author YangLinWei
     * @date 2017/2/10  11:33
     * @returnType
     */
    public static int getCurrentHour() {
        return Calendar.getInstance().get(Calendar.HOUR_OF_DAY);
    }

    /**
     * 获取每月的几号
     *
     * @param
     * @return
     * @author YangLinWei
     * @date 2017/2/17  16:07
     * @returnType
     */
    public static int getCurrentDate() {
        return Calendar.getInstance().get(Calendar.DAY_OF_MONTH);
    }

    /**
     * 获取当分
     *
     * @param
     * @return
     * @author YangLinWei
     * @date 2017/2/10  11:33
     * @returnType
     */
    public static int getCurrentMinute() {
        return Calendar.getInstance().get(Calendar.MINUTE);
    }

    /**
     * 比较当前时间是否处于开始时间和结束时间之间
     *
     * @param beginTime 开始时间，格式 hh:mm(时:分)
     * @param endTime   结束时间，格式 hh:mm(时:分)
     * @return true:处于开始时间和结束时间之间，false 不处于开始时间和结束时间之间
     * @author YangLinWei
     * @date 2017/2/10  11:23
     * @returnType boolean
     */
    public static boolean isCurTimeIn(String format, String beginTime, String endTime) {
        try {
            if (TextUtils.isEmpty(beginTime) || TextUtils.isEmpty(endTime)) {
                return false;
            }

            if (FORMAT_YYYY_MM_DD_HH_MM.equals(format)) {
                return isCurTimeIn_(beginTime, endTime);

            } else if (FORMAT_HH_MM.equals(format)) {
                SimpleDateFormat sdf = new SimpleDateFormat(DateUtil.FORMAT_HH_MM_SS);
                long timeStart = sdf.parse(beginTime + ":00").getTime();
                long timeEnd = sdf.parse(endTime + ":00").getTime();
                String curTime = String.format("%d:%d:00", getCurrentHour(), getCurrentMinute());
                long timeCurrent = sdf.parse(curTime).getTime();
                if (timeCurrent >= timeStart && timeCurrent < timeEnd) {
                    return true;
                }
            }

        } catch (Exception e) {
            Log.e(DateUtil.class.getName(), e.toString());
        }
        return false;
    }

    /**
     * 比较当前时间是否处于开始时间和结束时间之间
     *
     * @param startTime 开始时间，格式 yyyy-MM-dd hh:mm(年-月-日 时:分)
     * @param endTime   结束时间，格式 yyyy-MM-dd hh:mm(年-月-日 时:分)
     * @return true:处于开始时间和结束时间之间，false 不处于开始时间和结束时间之间
     * @author YangLinWei
     * @date 2017/04/07  15:23
     * @returnType boolean
     */
    public static boolean isCurTimeIn_(String startTime, String endTime) {
        try {
            SimpleDateFormat format = new SimpleDateFormat(DateUtil.FORMAT_YYYY_MM_DD_HH_MM_SS);
            long timeStart = format.parse(startTime + ":00").getTime();
            long timeEnd = format.parse(endTime + ":00").getTime();
            long timeCurrent = System.currentTimeMillis();
            if (timeCurrent >= timeStart && timeCurrent < timeEnd) {
                return true;
            }
        } catch (Exception e) {
            Log.e(DateUtil.class.getName(), e.toString());
        }
        return false;
    }

    /**
     * 检测当前时间是否在一个时间段内（针对于定时广播）
     *
     * @param exeCtime 执行时间
     * @param durTime  持续时间
     * @return true: 是在一个时间段里，false：不在一个时间段里
     * @author YangLinWei
     * @date 2017/3/2  16:04
     * @returnType boolean
     */
    public static boolean checkCurIn(String exeCtime, String durTime) {
        try {
            long beginTime = getExecTime4TimeBro(exeCtime);
            long endTime = getExecTime4TimeBro(exeCtime) + Long.parseLong(durTime) * 1000l;
            long curTime = System.currentTimeMillis();
            if (curTime >= beginTime && curTime < endTime) {
                return true;
            }
        } catch (Exception e) {
            Log.e(DateUtil.class.getName(), e.toString());
        }
        return false;
    }


    /**
     * 判断选择的时间是否比当前时间大
     *
     * @param
     * @return
     * @author lyw
     * @date 2019/3/4   15:23
     * @returnType
     */
    public static boolean checkChooseTime(String chooseTime) {
        try {
            String beginTime = new String(chooseTime);
            String curDate = getCurDateYMDHMS();
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date sd1 = df.parse(beginTime);
            Date sd2 = df.parse(curDate);
            if (sd1.after(sd2)) {
                return true;
            }
        } catch (Exception e) {
            Log.e(DateUtil.class.getName(), e.toString());
        }
        return false;
    }

    /**
     * 把字符串的日期类型转为long型(针对定时广播)
     *
     * @param exeTime: yyyy-MM-dd HH:mm:ss
     * @return
     * @author YangLinWei
     * @date 2017/3/2  16:59
     * @returnType
     */
    public static long getExecTime4TimeBro(String exeTime) {
        try {
            String execTime = getCurrentYear()
                    + "-" + (getCurrentMonth() + 1)
                    + "-" + getCurrentDate()
                    + " "
                    + exeTime
                    + ":00";
            SimpleDateFormat sdf = new SimpleDateFormat(DateUtil.FORMAT_YYYY_MM_DD_HH_MM_SS);
            Date date = sdf.parse(execTime);
            return date.getTime();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return 0;
    }

    public static long getExecTime4TimeBro1(String exeTime) {
        try {
            String execTime = getCurrentYear()
                    + "-" + (getCurrentMonth() + 1)
                    + "-" + getCurrentDate()
                    + " "
                    + exeTime;
            SimpleDateFormat sdf = new SimpleDateFormat(DateUtil.FORMAT_YYYY_MM_DD_HH_MM_SS);
            Date date = sdf.parse(execTime);
            return date.getTime();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return 0;
    }

    /**
     * @desc 返回统计月份数
     * @author luo_zi_zhao
     * @date create at 2018/12/26 15:23
     */
    public static int longToSumMonth(long sum) {
        return (int) (sum / 1000 / 60 / 60 / 24 / 30);
    }

    /**
     * 指定日期添加几天
     *
     * @param date 指定日期
     * @param day  5(加5天),-5(减5天)
     * @return 指定日期添加几天后的日期
     * @author christineRuan
     * @date 2019/1/23 15:21
     * @returnType Date
     */
    public static Date addDay(Date date, int day) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.DAY_OF_MONTH, day);
        date = calendar.getTime();
        return date;
    }

  /*  *//**
     * 指定日期添加几天
     *
     * @param dateStr 指定日期
     * @param day     5(加5天),-5(减5天)
     * @return 指定日期添加几天后的日期
     * @author christineRuan
     * @date 2019/1/23 15:21
     * @returnType String
     *//*
    public static String addDay(String dateStr, String day) {
        try {
            if (TextUtils.isEmpty(dateStr)) {
                return "1000-01-01";
            }
            Date date = DateUtil.stringToDate(dateStr, DateUtil.FORMAT_YYYY_MM_DD);
            if (!tex.isNum(day)) {
                day = "0";
            }
            int dayIn = Integer.parseInt(day);
            date = DateUtil.addDay(date, dayIn);
            return DateUtil.formatDate(date, DateUtil.FORMAT_YYYY_MM_DD);
        } catch (Exception e) {
            MyLog.error(Author.RUAN, DateUtil.class, "addDay", String.format("==》》》%s", e.toString()));
            return "1000-01-01";
        }
    }*/

    /**
     * 指定日期添加几天
     *
     * @param dateStr 指定日期
     * @param day     5(加5天),-5(减5天)
     * @return 指定日期添加几天后的日期
     * @author christineRuan
     * @date 2019/1/23 15:21
     * @returnType String
     */
    public static String addDay(String dateStr, long day) {
        try {
            if (TextUtils.isEmpty(dateStr)) {
                return "1000-01-01";
            }
            Date date = DateUtil.stringToDate(dateStr, DateUtil.FORMAT_YYYY_MM_DD);
            date = DateUtil.addDay(date, (int) day);
            return DateUtil.formatDate(date, DateUtil.FORMAT_YYYY_MM_DD);
        } catch (Exception e) {
            Log.e(DateUtil.class.getName(), e.toString());
            return "1000-01-01";
        }
    }

    /**
     * 判断日期是否当天
     *
     * @param
     * @return
     * @author lyw
     * @date 2019/3/6   16:52
     * @returnType
     */
    public static boolean isToday(String date) {
        SimpleDateFormat sdf = new SimpleDateFormat(DateUtil.FORMAT_YYYY_MM_DD);
        String now = sdf.format(new Date());//当前时间
        if (date.equals(now)) {
            return true;
        }
        return false;
    }
}
